package com.ruoyi.system.service.impl;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Arrays;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.common.core.domain.entity.SysDictTree;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.SysDictTreeMapper;
import com.ruoyi.system.service.ISysDictTreeService;

/**
 * 树形字典管理Service业务层处理
 *
 * @author ruoyi
 * @date 2025-06-06
 */
@Slf4j
@Service
public class SysDictTreeServiceImpl extends ServiceImpl<SysDictTreeMapper, SysDictTree> implements ISysDictTreeService {

    /**
     * 查询树形字典管理
     *
     * @param id 树形字典管理主键
     * @return 树形字典管理
     */
    @Override
    public SysDictTree selectSysDictTreeById(Long id) {
        return super.getById(id);
    }

    /**
     * 查询树形字典管理列表
     *
     * @param sysDictTree 树形字典管理
     * @return 树形字典管理
     */
    @Override
    public List<SysDictTree> selectSysDictTreeList(SysDictTree sysDictTree) {
        return baseMapper.selectSysDictTreeList(sysDictTree);
    }

    /**
     * 新增树形字典管理
     *
     * @param sysDictTree 树形字典管理
     * @return 结果
     */
    @Override
    public boolean insertSysDictTree(SysDictTree sysDictTree) {
        sysDictTree.setCreateTime(DateUtils.getNowDate());
        sysDictTree.setCreateBy(SecurityUtils.getUsername());
        if (sysDictTree.getParentId().intValue() != 0) {
            SysDictTree parent = super.getById(sysDictTree.getParentId());
            if (parent != null) {
                sysDictTree.setDictType(parent.getDictType());
                sysDictTree.setAncestors(parent.getAncestors() + "," + sysDictTree.getParentId());
            }
        } else {
            // 校验是否已经存在
            Long count = super.count(Wrappers.lambdaQuery(SysDictTree.class)
                    .eq(SysDictTree::getDictType, sysDictTree.getDictType())
                    .eq(SysDictTree::getParentId, 0)
            );
            if (count.intValue() > 0) {
                throw new BaseException("该字典类型已经存在，请勿重复添加");
            }
            sysDictTree.setDictValue("0");
            sysDictTree.setAncestors("0");
        }
        return super.save(sysDictTree);
    }

    /**
     * 修改树形字典管理
     *
     * @param sysDictTree 树形字典管理
     * @return 结果
     */
    @Override
    public boolean updateSysDictTree(SysDictTree sysDictTree) {
        sysDictTree.setUpdateTime(DateUtils.getNowDate());
        sysDictTree.setUpdateBy(SecurityUtils.getUsername());
        if (sysDictTree.getParentId().intValue() != 0) {
            SysDictTree parent = super.getById(sysDictTree.getParentId());
            if (parent != null) {
                sysDictTree.setDictType(parent.getDictType());
                sysDictTree.setAncestors(parent.getAncestors() + "," + sysDictTree.getParentId());
            }
        } else {
            // 校验是否已经存在
            Long count = super.count(Wrappers.lambdaQuery(SysDictTree.class)
                    .eq(SysDictTree::getDictType, sysDictTree.getDictType())
                    .eq(SysDictTree::getParentId, 0)
                    .ne(SysDictTree::getId, sysDictTree.getId())
            );
            if (count.intValue() > 0) {
                throw new BaseException("该字典类型已经存在，请勿重复添加");
            }
            sysDictTree.setDictValue("0");
            sysDictTree.setAncestors("0");
        }
        return super.updateById(sysDictTree);
    }

    /**
     * 批量删除树形字典管理
     *
     * @param ids 需要删除的树形字典管理主键
     * @return 结果
     */
    @Override
    public boolean deleteSysDictTreeByIds(Long[] ids) {
        return super.removeByIds(Arrays.asList(ids));
    }

    /**
     * 删除树形字典管理信息
     *
     * @param id 树形字典管理主键
     * @return 结果
     */
    @Override
    public boolean deleteSysDictTreeById(Long id) {
        return super.removeById(id);
    }

    @Override
    public List<SysDictTree> selectSysDictTreeByDictType(String dictType) {
        List<SysDictTree> list = super.list(Wrappers.lambdaQuery(SysDictTree.class)
                .ne(SysDictTree::getParentId, 0)
                .eq(SysDictTree::getDictType, dictType)
                .eq(SysDictTree::getStatus, "0")
        );
        if (StringUtils.isEmpty(list)) {
            return null;
        }
        return buildDictTree(list);
    }

    /**
     * 构建前端所需要树结构
     *
     * @param dictTrees 部门列表
     * @return 树结构列表
     */
    @Override
    public List<SysDictTree> buildDictTree(List<SysDictTree> dictTrees) {
        List<SysDictTree> resultList = new ArrayList<SysDictTree>();
        List<Long> tempList = new ArrayList<Long>();
        for (SysDictTree dictTree : dictTrees) {
            tempList.add(dictTree.getId());
        }
        for (Iterator<SysDictTree> iterator = dictTrees.iterator(); iterator.hasNext(); ) {
            SysDictTree dictTree = (SysDictTree) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(dictTree.getParentId())) {
                recursionFn(dictTrees, dictTree);
                resultList.add(dictTree);
            }
        }
        if (resultList.isEmpty()) {
            resultList = dictTrees;
        }
        return resultList;
    }

    /**
     * 递归列表
     */
    private void recursionFn(List<SysDictTree> list, SysDictTree t) {
        // 得到子节点列表
        List<SysDictTree> childList = getChildList(list, t);
        if(StringUtils.isNotEmpty(childList)){
            t.setChildren(childList);
            for (SysDictTree tChild : childList) {
                if (hasChild(list, tChild)) {
                    recursionFn(list, tChild);
                }
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private List<SysDictTree> getChildList(List<SysDictTree> list, SysDictTree t) {
        List<SysDictTree> tlist = new ArrayList<SysDictTree>();
        Iterator<SysDictTree> it = list.iterator();
        while (it.hasNext()) {
            SysDictTree n = (SysDictTree) it.next();
            if (StringUtils.isNotNull(n.getParentId()) && n.getParentId() == t.getId()) {
                tlist.add(n);
            }
        }
        return tlist;
    }

    /**
     * 判断是否有子节点
     */
    private boolean hasChild(List<SysDictTree> list, SysDictTree t) {
        return getChildList(list, t).size() > 0 ? true : false;
    }

}
